package java8;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class StreamTest {
    public static void main(String[] args) {
        //从集合创建 Stream
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        Stream<String> stream1 = list.stream();
        System.out.println(Arrays.toString(stream1.toArray()));

        //从数组创建 Stream
        String[] array = {"apple", "banana", "cherry"};
        Stream<String> stream2 = Arrays.stream(array);
        System.out.println(Arrays.toString(stream2.toArray()));

        //使用 Stream.of() 创建 Stream
        Stream<String> stream3 = Stream.of("apple", "banana", "cherry");
        System.out.println(Arrays.toString(stream3.toArray()));


        //中间操作 filter：用于过滤流中的元素，返回符合条件的元素。
        List<String> filteredList = list.stream()
                .filter(s -> s.startsWith("a"))
                .collect(Collectors.toList());
        System.out.println(filteredList); // 输出: [apple]

        //中间操作 map：用于将流中的元素通过函数转换成另一个类型的元素（通常是映射操作）
        List<String> upperCaseList = list.stream()
                .map(String::toUpperCase)
                .collect(Collectors.toList());
        System.out.println(upperCaseList); // 输出: [APPLE, BANANA, CHERRY]

        // distinct：去除重复的元素
        List<String> list1 = Arrays.asList("apple", "banana", "apple", "cherry");
        List<String> distinctList = list1.stream()
                                          .distinct()
                                          .collect(Collectors.toList());
        System.out.println(distinctList); // 输出: [apple, banana, cherry]

        //sorted：对流中的元素进行排序。
        List<String> sortedList = list.stream()
                .sorted()
                .collect(Collectors.toList());
        System.out.println(sortedList); // 输出: [apple, banana, cherry]

        //flatMap：将流中的每个元素映射成多个元素，然后再将所有这些元素合并成一个流
        List<List<String>> listOfLists = Arrays.asList(
                Arrays.asList("apple", "banana"),
                Arrays.asList("cherry", "date"));

        List<String> flatMappedList = listOfLists.stream()
                .flatMap(List::stream)
                .collect(Collectors.toList());
        System.out.println(flatMappedList); // 输出: [apple, banana, cherry, date]

        //collect：将流中的元素收集到集合中，是最常用的终止操作。
        List<String> result = new ArrayList<>(list);
        System.out.println(result); // 输出: [apple, banana, cherry]

        //forEach：对流中的每个元素进行操作，通常用于打印
        List<String> list3 = Arrays.asList("apple", "banana", "cherry");
        list3.stream().forEach(System.out::println);

        //reduce：用于对流中的元素进行累加或合并，通常用于求和、求最小值或求最大值
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        int sum = numbers.stream()
                .reduce(0, Integer::sum);
        System.out.println(sum); // 输出: 15

        //anyMatch：检查流中的任何一个元素是否符合指定的条件
        boolean hasApple = list.stream()
                .anyMatch(s -> s.equals("apple"));
        System.out.println(hasApple); // 输出: true

        // allMatch：检查流中的所有元素是否符合指定的条件
        boolean allStartWithA = list.stream()
                .allMatch(s -> s.startsWith("a"));
        System.out.println(allStartWithA); // 输出: false

        //count：计算流中元素的数量
        long count = list.stream().count();
        System.out.println(count); // 输出: 3

        int sum2 = numbers.parallelStream()
                .reduce(0, Integer::sum);
        System.out.println(sum2); // 输出: 15


    }
}
